package DataStructureAndAlgorithm.CSP.Day07;
import java.util.*;
public class AcWing_3224 {
    static int N = 110;
    static char[][] grid = new char[N][N];
    static boolean[][] st = new boolean[N][N];
    static int n,m,q;
    public static void main(String[] args){
        Scanner in = new Scanner(System.in);
        m = in.nextInt();
        n = in.nextInt();
        q = in.nextInt();
        for (int i = 0; i < m; i++){
            for (int j = 0; j < n; j++){
                grid[i][j] = '.';
            }
        }
        for (int k = 0; k < q; k++){
            int type = in.nextInt();
            if (type == 0){
                int x1 = in.nextInt();
                int y1 = in.nextInt();
                int x2 = in.nextInt();
                int y2 = in.nextInt();
                //保证y1<y2,x1<x2
                if (x1 > x2){
                    int temp = x1;
                    x1 = x2;
                    x2 = temp;
                }
                if (y1 > y2){
                    int temp = y1;
                    y1 = y2;
                    y2 = temp;
                }
                char c = '-';
                char d = '|';
                if (x1 == x2){
                    char temp = c;
                    c = d;
                    d = temp;
                }
                //从小的坐标循环到大的坐标，进行画线操作
                for (int i = x1; i <= x2; i++){
                    for (int j = y1; j <= y2; j++){
                        if (grid[i][j] == d || grid[i][j] == '+'){
                            grid[i][j] = '+';
                        }else {
                            grid[i][j] = c;
                        }
                    }
                }
            }else {
                //进行填充操作，dfs即可，需要注意用判重数组st求解
                int x = in.nextInt();
                int y = in.nextInt();
                char ch = in.next().charAt(0);
                for (int i = 0; i < N; i++){
                    Arrays.fill(st[i],false);
                }
                dfs(x,y,ch);
            }
        }
        //将数组坐标转换成数学坐标
        for (int i = n - 1; i >= 0; i--){
            for (int j = 0; j < m; j++){
                System.out.print(grid[j][i]);
            }
            System.out.println();
        }
    }
    //常用偏移量技巧
    static int[] dx = {-1,0,1,0};
    static int[] dy = {0,1,0,-1};
    static void dfs(int x,int y,char ch){
        grid[x][y] = ch;
        st[x][y] = true;
        for (int i = 0; i < 4; i++){
            int a = x + dx[i];
            int b = y + dy[i];
            if (a >= 0 && a < m && b >= 0 && b < n && !st[a][b]){
                if (grid[a][b] == '-' || grid[a][b] == '|' || grid[a][b] == '+')continue;
                else dfs(a,b,ch);
            }
        }
    }
}
/*
用 ASCII 字符来画图是一件有趣的事情，并形成了一门被称为 ASCII Art 的艺术。

例如，下图是用 ASCII 字符画出来的 CSPRO 字样。

　　..____.____..____..____...___..
　　./.___/.___||.._.\|.._.\./._.\.
　　|.|...\___.\|.|_).|.|_).|.|.|.|
　　|.|___.___).|..__/|.._.<|.|_|.|
　　.\____|____/|_|...|_|.\_\\___/.

本题要求编程实现一个用 ASCII 字符来画图的程序，支持以下两种操作：

    画线：给出两个端点的坐标，画一条连接这两个端点的线段。简便起见题目保证要画的每条线段都是水平或者竖直的。水平线段用字符 - 来画，竖直线段用字符 | 来画。如果一条水平线段和一条竖直线段在某个位置相交，则相交位置用字符 + 代替。
    填充：给出填充的起始位置坐标和需要填充的字符，从起始位置开始，用该字符填充相邻位置，直到遇到画布边缘或已经画好的线段。注意这里的相邻位置只需要考虑上下左右 4

个方向，如下图所示，字符 @ 只和 4

    个字符 * 相邻。

　　.*.
　　*@*
　　.*.

输入格式

第 1
行有三个整数 m,n 和 q。m 和 n 分别表示画布的宽度和高度，以字符为单位。q

表示画图操作的个数。

第 2
行至第 q+1

行，每行是以下两种形式之一：

    0 x1 y1 x2 y2：表示画线段的操作，(x1,y1)

和 (x2,y2) 分别是线段的两端，满足要么 x1=x2 且 y1≠y2，要么 y1=y2 且 x1≠x2
。
1 x y c：表示填充操作，(x,y)
是起始位置，保证不会落在任何已有的线段上；c

    为填充字符，是大小写字母。

画布的左下角是坐标为 (0,0)
的位置，向右为 x 坐标增大的方向，向上为 y

坐标增大的方向。

这 q

个操作按照数据给出的顺序依次执行。画布最初时所有位置都是字符 .（小数点）。
输出格式

输出有 n
行，每行 m 个字符，表示依次执行这 q

个操作后得到的画图结果。
数据范围

2≤m,n≤100
，
0≤q≤100，
0≤x<m（x 表示输入数据中所有位置的 x 坐标），
0≤y<n（y 表示输入数据中所有位置的 y

坐标）。
输入样例1：

4 2 3
1 0 0 B
0 1 0 2 0
1 0 0 A

输出样例1：

AAAA
A--A

输入样例2：

16 13 9
0 3 1 12 1
0 12 1 12 3
0 12 3 6 3
0 6 3 6 9
0 6 9 12 9
0 12 9 12 11
0 12 11 3 11
0 3 11 3 1
1 4 2 C

输出样例2：

................
...+--------+...
...|CCCCCCCC|...
...|CC+-----+...
...|CC|.........
...|CC|.........
...|CC|.........
...|CC|.........
...|CC|.........
...|CC+-----+...
...|CCCCCCCC|...
...+--------+...
................

 */